package coverage.sketch;

import treemap.TreeMap;
import junit.framework.TestCase;

public class SketchTestTreeMap extends TestCase {

	public void testRemove00(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove01(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove02(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove10(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove11(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove12(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove20(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove21(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove22(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove30(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove31(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove32(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove40(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove41(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove42(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove50(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove51(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove52(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove53(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove60(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove61(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove62(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove63(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove64(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove70(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove71(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove72(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove73(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove74(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove80(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove81(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove82(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove83(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove90(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove91(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove92(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove100(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove101(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove102(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove103(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove110(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove111(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove112(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove113(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove114(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove120(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove121(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove122(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove123(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove124(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove130(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove131(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove132(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove133(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove140(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove141(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove142(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove150(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove151(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove152(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove153(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove160(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove161(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove162(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove163(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove164(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove170(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove171(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove172(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove173(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove174(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove180(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove181(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove182(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove183(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove190(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove191(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove192(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove200(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove201(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove202(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove210(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove211(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove212(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove213(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove220(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove221(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove222(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove223(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove224(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove230(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove231(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove232(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove233(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove234(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,1}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove240(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove241(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove242(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove243(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove250(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove251(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove252(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove253(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove260(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove261(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove262(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove263(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove264(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove270(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove271(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove272(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove273(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove274(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove275(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,1}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove280(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove281(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove282(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove283(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove284(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove290(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove291(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove292(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove293(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove294(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove300(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove301(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove302(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove303(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove304(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove310(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove311(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove312(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove313(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove314(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove315(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,1}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove320(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove321(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove322(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove323(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove324(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,1}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove330(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove331(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove332(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove333(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove334(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove335(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,1}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove340(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove341(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove342(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove343(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove344(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove345(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,1}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove350(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove351(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove352(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove353(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove354(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,1}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove360(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,2}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove361(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove362(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove363(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove370(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove371(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,2}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove372(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove373(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove380(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove381(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,2}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove382(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove383(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove384(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove390(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove391(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,2}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove392(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove393(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove394(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove395(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,2}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove400(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,2}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove401(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove402(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove403(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove410(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove411(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove412(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove420(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove421(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove422(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove423(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove430(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove431(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove432(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove433(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove434(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,2}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove440(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove441(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,2}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove442(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove443(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove444(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove450(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove451(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove452(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove453(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove460(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove461(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove462(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove463(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove470(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove471(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove472(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove473(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove474(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,2}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove480(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove481(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,2}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove482(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove483(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove484(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove485(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,2}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove490(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove491(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove492(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove493(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove494(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,2}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove500(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove501(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove502(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove503(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove504(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,2}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove510(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove511(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove512(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove513(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove514(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,2}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove520(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,3}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove521(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove522(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove523(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove524(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove530(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove531(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,3}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove532(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove533(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove534(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove540(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove541(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,3}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove542(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove543(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove544(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove550(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove551(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,3}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove552(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove553(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove554(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove555(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,3}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove560(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove561(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,3}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove562(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove563(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove564(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove570(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove571(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove572(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove573(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove580(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove581(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove582(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove583(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove590(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove591(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove592(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove593(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove594(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,3}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove600(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,3}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove601(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove602(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove603(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove604(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove610(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove611(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove612(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove613(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove620(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove621(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove622(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove630(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove631(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove632(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove633(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,3}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove640(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove641(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,3}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove642(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove643(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove644(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove645(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,3}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove650(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove651(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove652(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove653(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove654(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,3}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove660(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove661(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove662(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove663(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,3}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove670(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove671(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove672(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove673(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,3}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove680(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,4}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove681(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove682(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove683(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove684(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove690(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove691(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,4}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove692(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove693(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove694(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove695(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove700(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove701(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,4}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove702(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove703(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove704(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove705(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove710(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove711(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,4}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove712(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove713(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove714(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove720(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove721(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,4}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove722(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove723(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove724(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove725(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove730(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove731(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove732(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove733(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove734(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove740(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove741(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove742(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove743(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove744(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove750(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove751(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove752(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove753(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove754(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove760(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove761(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,4}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove762(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove763(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove764(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove765(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove770(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove771(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove772(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove773(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove774(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove780(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove781(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove782(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove783(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove790(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove791(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove792(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove793(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove800(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,4}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove801(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove802(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove803(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove804(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove810(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove811(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove812(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove813(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove814(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove820(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove821(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove822(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove823(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove830(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove831(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove832(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove840(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,1,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove841(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,1,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove842(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,1,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove850(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,1,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove851(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,1,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove852(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,1,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove853(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,1,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove860(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,1,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove861(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,1,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove862(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,1,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove863(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,1,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove864(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,1,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove870(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,1,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove871(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,1,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove872(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,1,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove873(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,1,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove874(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,1,1}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove880(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,1,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove881(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,1,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove882(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,1,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove883(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,1,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove890(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,1,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove891(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,1,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove892(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,1,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove893(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,1,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove900(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,1,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove901(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,1,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove902(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,1,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove903(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,1,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove904(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,1,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove910(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,1,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove911(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,1,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove912(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,1,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove913(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,1,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove914(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,1,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove915(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,1,1}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove920(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,1,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove921(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,1,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove922(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,1,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove923(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,1,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove924(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,1,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove930(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,1,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove931(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,1,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove932(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,1,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove933(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,1,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove934(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,1,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove940(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,1,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove941(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,1,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove942(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,1,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove943(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,1,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove944(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,1,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove950(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,1,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove951(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,1,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove952(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,1,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove953(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,1,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove954(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,1,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove955(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,1,1}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove960(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,1,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove961(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,1,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove962(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,1,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove963(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,1,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove964(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,1,1}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove970(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,1,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove971(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,1,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove972(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,1,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove973(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,1,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove974(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,1,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove975(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,1,1}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove980(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,1,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove981(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,1,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove982(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,1,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove983(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,1,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove984(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,1,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove985(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,1,1}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove990(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,1,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove991(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,1,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove992(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,1,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove993(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,1,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove994(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,1,1}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove1000(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,2,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1001(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,2,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1002(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,2,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1003(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,2,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1010(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,2,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1011(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,2,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1012(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,2,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1013(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,2,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1020(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,2,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1021(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,2,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1022(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,2,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1023(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,2,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1024(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,2,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1030(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,2,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1031(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,2,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1032(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,2,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1033(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,2,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1034(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,2,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1035(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,2,1}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove1040(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,2,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1041(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,2,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1042(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,2,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1043(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,2,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1050(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,2,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1051(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,2,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1052(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,2,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1053(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,2,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1060(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,2,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1061(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,2,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1062(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,2,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1063(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,2,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1064(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,2,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1070(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,2,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1071(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,2,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1072(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,2,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1073(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,2,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1074(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,2,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1075(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,2,1}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove1080(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,2,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1081(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,2,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1082(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,2,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1083(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,2,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1084(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,2,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1090(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,2,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1091(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,2,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1092(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,2,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1093(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,2,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1094(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,2,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1100(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,2,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1101(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,2,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1102(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,2,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1103(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,2,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1104(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,2,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1110(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,2,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1111(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,2,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1112(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,2,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1113(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,2,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1114(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,2,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1115(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,2,1}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove1120(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,2,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1121(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,2,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1122(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,2,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1123(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,2,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1124(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,2,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1125(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,2,1}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove1130(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,2,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1131(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,2,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1132(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,2,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1133(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,2,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1134(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,2,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1135(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,2,1}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove1140(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,2,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1141(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,2,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1142(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,2,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1143(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,2,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1144(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,2,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1145(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,2,1}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove1150(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,2,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1151(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,2,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1152(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,2,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1153(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,2,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1154(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,2,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1155(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,2,1}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove1160(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,3,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1161(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,3,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1162(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,3,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1163(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,3,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1164(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,3,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1170(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,3,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1171(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,3,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1172(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,3,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1173(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,3,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1174(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,3,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1180(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,3,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1181(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,3,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1182(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,3,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1183(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,3,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1184(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,3,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1190(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,3,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1191(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,3,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1192(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,3,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1193(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,3,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1194(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,3,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1195(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,3,1}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove1200(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,3,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1201(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,3,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1202(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,3,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1203(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,3,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1204(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,3,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1210(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,3,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1211(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,3,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1212(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,3,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1213(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,3,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1214(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,3,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1220(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,3,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1221(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,3,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1222(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,3,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1223(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,3,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1224(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,3,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1230(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,3,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1231(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,3,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1232(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,3,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1233(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,3,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1234(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,3,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1235(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,3,1}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove1240(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,3,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1241(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,3,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1242(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,3,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1243(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,3,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1244(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,3,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1250(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,3,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1251(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,3,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1252(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,3,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1253(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,3,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1254(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,3,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1260(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,3,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1261(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,3,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1262(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,3,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1263(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,3,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1264(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,3,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1270(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,3,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1271(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,3,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1272(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,3,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1273(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,3,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1274(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,3,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1275(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,3,1}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove1280(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,3,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1281(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,3,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1282(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,3,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1283(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,3,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1284(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,3,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1285(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,3,1}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove1290(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,3,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1291(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,3,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1292(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,3,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1293(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,3,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1294(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,3,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1295(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,3,1}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove1300(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,3,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1301(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,3,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1302(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,3,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1303(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,3,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1304(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,3,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1305(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,3,1}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove1310(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,3,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1311(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,3,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1312(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,3,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1313(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,3,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1314(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,3,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1315(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,3,1}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove1320(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,4,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1321(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,4,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1322(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,4,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1323(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,4,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1324(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,4,1}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove1330(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,4,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1331(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,4,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1332(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,4,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1333(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,4,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1334(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,4,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1335(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,4,1}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove1340(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,4,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1341(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,4,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1342(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,4,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1343(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,4,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1344(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,4,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1345(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,4,1}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove1350(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,4,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1351(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,4,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1352(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,4,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1353(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,4,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1354(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,4,1}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove1360(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,4,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1361(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,4,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1362(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,4,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1363(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,4,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1364(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,4,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1365(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,4,1}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove1370(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,4,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1371(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,4,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1372(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,4,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1373(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,4,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1374(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,4,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1375(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,4,1}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove1380(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,4,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1381(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,4,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1382(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,4,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1383(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,4,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1384(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,4,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1385(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,4,1}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove1390(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,4,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1391(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,4,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1392(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,4,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1393(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,4,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1394(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,4,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1395(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,4,1}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove1400(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,4,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1401(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,4,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1402(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,4,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1403(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,4,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1404(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,4,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1405(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,4,1}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove1410(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,4,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1411(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,4,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1412(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,4,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1413(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,4,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1414(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,4,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1415(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,4,1}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove1420(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,4,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1421(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,4,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1422(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,4,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1423(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,4,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1424(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,4,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1425(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,4,1}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove1430(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,4,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1431(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,4,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1432(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,4,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1433(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,4,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1434(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,4,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1435(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,4,1}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove1440(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,4,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1441(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,4,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1442(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,4,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1443(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,4,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1444(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,4,1}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove1450(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,4,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1451(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,4,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1452(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,4,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1453(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,4,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1454(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,4,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1455(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,4,1}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove1460(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,4,1}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1461(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,4,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1462(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,4,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1463(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,4,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1464(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,4,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1465(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,4,1}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove1470(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,4,1}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1471(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,4,1}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1472(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,4,1}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1473(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,4,1}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1474(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,4,1}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove1480(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,1,2}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1481(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,1,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1482(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,1,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1483(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,1,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1490(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,1,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1491(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,1,2}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1492(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,1,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1493(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,1,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1500(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,1,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1501(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,1,2}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1502(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,1,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1503(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,1,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1504(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,1,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1510(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,1,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1511(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,1,2}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1512(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,1,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1513(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,1,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1514(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,1,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1515(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,1,2}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove1520(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,1,2}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1521(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,1,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1522(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,1,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1523(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,1,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1530(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,1,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1531(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,1,2}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1532(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,1,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1533(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,1,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1540(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,1,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1541(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,1,2}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1542(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,1,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1543(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,1,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1544(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,1,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1550(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,1,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1551(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,1,2}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1552(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,1,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1553(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,1,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1554(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,1,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1555(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,1,2}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove1560(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,1,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1561(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,1,2}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1562(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,1,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1563(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,1,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1564(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,1,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1570(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,1,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1571(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,1,2}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1572(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,1,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1573(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,1,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1574(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,1,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1580(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,1,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1581(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,1,2}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1582(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,1,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1583(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,1,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1584(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,1,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1590(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,1,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1591(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,1,2}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1592(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,1,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1593(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,1,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1594(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,1,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1595(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,1,2}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove1600(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,1,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1601(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,1,2}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1602(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,1,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1603(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,1,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1604(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,1,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1605(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,1,2}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove1610(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,1,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1611(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,1,2}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1612(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,1,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1613(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,1,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1614(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,1,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1615(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,1,2}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove1620(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,1,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1621(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,1,2}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1622(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,1,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1623(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,1,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1624(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,1,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1625(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,1,2}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove1630(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,1,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1631(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,1,2}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1632(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,1,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1633(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,1,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1634(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,1,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1635(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,1,2}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove1640(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,2,2}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1641(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,2,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1642(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,2,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1643(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,2,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1650(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,2,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1651(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,2,2}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1652(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,2,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1653(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,2,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1660(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,2,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1661(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,2,2}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1662(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,2,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1663(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,2,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1664(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,2,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1670(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,2,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1671(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,2,2}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1672(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,2,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1673(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,2,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1674(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,2,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1675(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,2,2}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove1680(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,2,2}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1681(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,2,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1682(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,2,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1683(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,2,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1690(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,2,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1691(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,2,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1692(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,2,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1700(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,2,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1701(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,2,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1702(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,2,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1703(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,2,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1710(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,2,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1711(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,2,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1712(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,2,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1713(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,2,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1714(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,2,2}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove1720(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,2,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1721(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,2,2}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1722(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,2,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1723(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,2,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1724(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,2,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1730(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,2,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1731(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,2,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1732(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,2,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1733(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,2,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1740(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,2,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1741(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,2,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1742(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,2,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1743(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,2,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1750(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,2,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1751(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,2,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1752(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,2,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1753(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,2,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1754(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,2,2}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove1760(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,2,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1761(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,2,2}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1762(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,2,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1763(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,2,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1764(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,2,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1765(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,2,2}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove1770(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,2,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1771(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,2,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1772(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,2,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1773(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,2,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1774(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,2,2}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove1780(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,2,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1781(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,2,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1782(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,2,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1783(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,2,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1784(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,2,2}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove1790(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,2,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1791(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,2,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1792(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,2,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1793(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,2,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1794(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,2,2}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove1800(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,3,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1801(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,3,2}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1802(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,3,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1803(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,3,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1804(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,3,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1810(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,3,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1811(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,3,2}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1812(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,3,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1813(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,3,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1814(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,3,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1820(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,3,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1821(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,3,2}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1822(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,3,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1823(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,3,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1824(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,3,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1830(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,3,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1831(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,3,2}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1832(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,3,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1833(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,3,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1834(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,3,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1835(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,3,2}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove1840(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,3,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1841(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,3,2}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1842(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,3,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1843(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,3,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1844(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,3,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1850(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,3,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1851(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,3,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1852(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,3,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1853(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,3,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1860(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,3,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1861(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,3,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1862(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,3,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1863(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,3,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1870(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,3,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1871(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,3,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1872(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,3,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1873(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,3,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1874(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,3,2}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove1880(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,3,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1881(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,3,2}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1882(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,3,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1883(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,3,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1884(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,3,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1890(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,3,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1891(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,3,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1892(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,3,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1893(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,3,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1900(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,3,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1901(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,3,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1902(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,3,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1903(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,3,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1910(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,3,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1911(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,3,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1912(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,3,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1913(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,3,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1914(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,3,2}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove1920(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,3,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1921(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,3,2}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1922(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,3,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1923(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,3,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1924(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,3,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1925(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,3,2}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove1930(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,3,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1931(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,3,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1932(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,3,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1933(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,3,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1934(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,3,2}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove1940(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,3,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1941(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,3,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1942(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,3,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1943(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,3,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1944(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,3,2}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove1950(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,3,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1951(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,3,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1952(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,3,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1953(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,3,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1954(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,3,2}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove1960(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,4,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1961(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,4,2}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1962(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,4,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1963(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,4,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1964(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,4,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1965(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,4,2}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove1970(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,4,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1971(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,4,2}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1972(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,4,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1973(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,4,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1974(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,4,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1975(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,4,2}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove1980(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,4,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1981(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,4,2}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1982(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,4,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1983(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,4,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1984(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,4,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1985(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,4,2}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove1990(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,4,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove1991(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,4,2}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove1992(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,4,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove1993(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,4,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove1994(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,4,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove1995(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,4,2}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2000(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,4,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2001(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,4,2}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove2002(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,4,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2003(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,4,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2004(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,4,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2005(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,4,2}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2010(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,4,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2011(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,4,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2012(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,4,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2013(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,4,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2014(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,4,2}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2020(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,4,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2021(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,4,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2022(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,4,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2023(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,4,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2024(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,4,2}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2030(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,4,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2031(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,4,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2032(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,4,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2033(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,4,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2034(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,4,2}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2040(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,4,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2041(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,4,2}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove2042(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,4,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2043(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,4,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2044(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,4,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2045(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,4,2}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2050(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,4,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2051(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,4,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2052(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,4,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2053(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,4,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2054(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,4,2}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2060(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,4,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2061(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,4,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2062(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,4,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2063(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,4,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2064(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,4,2}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2070(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,4,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2071(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,4,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2072(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,4,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2073(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,4,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2074(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,4,2}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2080(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,4,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2081(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,4,2}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove2082(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,4,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2083(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,4,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2084(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,4,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2085(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,4,2}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2090(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,4,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2091(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,4,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2092(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,4,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2093(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,4,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2094(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,4,2}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2100(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,4,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2101(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,4,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2102(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,4,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2103(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,4,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2104(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,4,2}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2110(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,4,2}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2111(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,4,2}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2112(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,4,2}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2113(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,4,2}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2114(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,4,2}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2120(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,1,3}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove2121(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,1,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2122(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,1,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2123(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,1,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2124(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,1,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2130(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,1,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2131(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,1,3}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove2132(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,1,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2133(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,1,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2134(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,1,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2140(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,1,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2141(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,1,3}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove2142(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,1,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2143(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,1,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2144(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,1,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2150(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,1,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2151(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,1,3}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove2152(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,1,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2153(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,1,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2154(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,1,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2155(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,1,3}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2160(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,1,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2161(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,1,3}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove2162(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,1,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2163(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,1,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2164(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,1,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2170(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,1,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2171(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,1,3}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove2172(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,1,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2173(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,1,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2174(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,1,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2180(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,1,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2181(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,1,3}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove2182(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,1,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2183(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,1,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2184(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,1,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2190(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,1,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2191(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,1,3}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove2192(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,1,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2193(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,1,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2194(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,1,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2195(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,1,3}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2200(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,1,3}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove2201(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,1,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2202(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,1,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2203(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,1,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2204(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,1,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2210(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,1,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2211(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,1,3}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove2212(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,1,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2213(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,1,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2214(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,1,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2220(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,1,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2221(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,1,3}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove2222(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,1,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2223(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,1,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2224(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,1,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2230(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,1,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2231(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,1,3}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove2232(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,1,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2233(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,1,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2234(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,1,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2235(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,1,3}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2240(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,1,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2241(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,1,3}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove2242(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,1,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2243(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,1,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2244(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,1,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2245(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,1,3}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2250(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,1,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2251(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,1,3}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove2252(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,1,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2253(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,1,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2254(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,1,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2255(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,1,3}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2260(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,1,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2261(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,1,3}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove2262(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,1,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2263(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,1,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2264(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,1,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2265(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,1,3}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2270(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,1,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2271(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,1,3}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove2272(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,1,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2273(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,1,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2274(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,1,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2275(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,1,3}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2280(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,2,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2281(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,2,3}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove2282(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,2,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2283(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,2,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2284(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,2,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2290(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,2,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2291(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,2,3}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove2292(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,2,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2293(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,2,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2294(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,2,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2300(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,2,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2301(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,2,3}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove2302(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,2,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2303(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,2,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2304(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,2,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2310(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,2,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2311(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,2,3}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove2312(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,2,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2313(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,2,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2314(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,2,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2315(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,2,3}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2320(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,2,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2321(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,2,3}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove2322(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,2,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2323(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,2,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2324(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,2,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2330(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,2,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2331(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,2,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2332(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,2,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2333(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,2,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2340(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,2,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2341(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,2,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2342(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,2,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2343(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,2,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2350(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,2,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2351(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,2,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2352(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,2,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2353(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,2,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2354(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,2,3}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2360(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,2,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2361(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,2,3}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove2362(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,2,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2363(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,2,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2364(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,2,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2370(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,2,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2371(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,2,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2372(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,2,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2373(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,2,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2380(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,2,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2381(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,2,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2382(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,2,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2383(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,2,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2390(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,2,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2391(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,2,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2392(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,2,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2393(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,2,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2394(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,2,3}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2400(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,2,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2401(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,2,3}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove2402(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,2,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2403(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,2,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2404(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,2,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2405(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,2,3}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2410(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,2,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2411(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,2,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2412(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,2,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2413(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,2,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2414(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,2,3}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2420(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,2,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2421(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,2,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2422(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,2,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2423(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,2,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2424(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,2,3}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2430(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,2,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2431(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,2,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2432(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,2,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2433(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,2,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2434(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,2,3}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2440(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,3,3}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove2441(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,3,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2442(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,3,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2443(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,3,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2444(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,3,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2450(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,3,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2451(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,3,3}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove2452(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,3,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2453(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,3,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2454(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,3,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2460(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,3,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2461(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,3,3}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove2462(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,3,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2463(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,3,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2464(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,3,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2470(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,3,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2471(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,3,3}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove2472(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,3,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2473(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,3,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2474(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,3,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2475(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,3,3}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2480(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,3,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2481(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,3,3}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove2482(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,3,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2483(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,3,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2484(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,3,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2490(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,3,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2491(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,3,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2492(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,3,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2493(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,3,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2500(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,3,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2501(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,3,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2502(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,3,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2503(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,3,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2510(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,3,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2511(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,3,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2512(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,3,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2513(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,3,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2514(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,3,3}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2520(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,3,3}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove2521(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,3,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2522(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,3,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2523(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,3,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2524(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,3,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2530(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,3,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2531(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,3,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2532(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,3,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2533(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,3,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2540(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,3,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2541(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,3,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2542(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,3,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2550(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,3,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2551(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,3,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2552(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,3,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2553(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,3,3}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2560(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,3,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2561(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,3,3}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove2562(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,3,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2563(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,3,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2564(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,3,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2565(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,3,3}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2570(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,3,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2571(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,3,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2572(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,3,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2573(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,3,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2574(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,3,3}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2580(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,3,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2581(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,3,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2582(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,3,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2583(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,3,3}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2590(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,3,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2591(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,3,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2592(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,3,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2593(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,3,3}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2600(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,4,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2601(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,4,3}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove2602(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,4,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2603(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,4,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2604(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,4,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2605(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,4,3}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2610(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,4,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2611(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,4,3}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove2612(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,4,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2613(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,4,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2614(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,4,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2615(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,4,3}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2620(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,4,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2621(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,4,3}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove2622(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,4,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2623(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,4,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2624(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,4,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2625(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,4,3}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2630(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,4,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2631(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,4,3}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove2632(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,4,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2633(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,4,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2634(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,4,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2635(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,4,3}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2640(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,4,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2641(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,4,3}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove2642(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,4,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2643(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,4,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2644(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,4,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2645(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,4,3}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2650(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,4,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2651(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,4,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2652(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,4,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2653(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,4,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2654(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,4,3}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2660(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,4,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2661(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,4,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2662(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,4,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2663(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,4,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2664(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,4,3}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2670(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,4,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2671(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,4,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2672(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,4,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2673(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,4,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2674(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,4,3}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2680(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,4,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2681(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,4,3}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove2682(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,4,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2683(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,4,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2684(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,4,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2685(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,4,3}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2690(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,4,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2691(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,4,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2692(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,4,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2693(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,4,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2694(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,4,3}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2700(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,4,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2701(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,4,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2702(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,4,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2703(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,4,3}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2710(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,4,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2711(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,4,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2712(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,4,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2713(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,4,3}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2720(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,4,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2721(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,4,3}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove2722(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,4,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2723(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,4,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2724(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,4,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2725(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,4,3}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2730(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,4,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2731(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,4,3}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2732(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,4,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2733(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,4,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2734(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,4,3}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2740(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,4,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2741(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,4,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2742(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,4,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2743(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,4,3}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2750(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,4,3}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2751(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,4,3}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2752(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,4,3}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2753(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,4,3}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2760(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,1,4}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove2761(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,1,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2762(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,1,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2763(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,1,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2764(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,1,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2770(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,1,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2771(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,1,4}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove2772(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,1,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2773(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,1,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2774(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,1,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2775(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,1,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2780(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,1,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2781(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,1,4}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove2782(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,1,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2783(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,1,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2784(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,1,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2785(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,1,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2790(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,1,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2791(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,1,4}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove2792(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,1,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2793(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,1,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2794(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,1,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2800(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,1,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2801(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,1,4}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove2802(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,1,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2803(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,1,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2804(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,1,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2805(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,1,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2810(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,1,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2811(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,1,4}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove2812(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,1,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2813(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,1,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2814(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,1,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2815(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,1,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2820(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,1,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2821(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,1,4}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove2822(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,1,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2823(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,1,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2824(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,1,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2825(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,1,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2830(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,1,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2831(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,1,4}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove2832(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,1,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2833(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,1,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2834(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,1,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2835(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,1,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2840(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,1,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2841(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,1,4}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove2842(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,1,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2843(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,1,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2844(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,1,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2845(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,1,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2850(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,1,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2851(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,1,4}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove2852(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,1,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2853(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,1,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2854(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,1,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2855(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,1,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2860(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,1,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2861(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,1,4}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove2862(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,1,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2863(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,1,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2864(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,1,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2865(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,1,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2870(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,1,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2871(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,1,4}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove2872(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,1,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2873(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,1,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2874(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,1,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2875(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,1,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2880(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,1,4}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove2881(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,1,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2882(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,1,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2883(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,1,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2884(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,1,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2890(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,1,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2891(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,1,4}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove2892(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,1,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2893(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,1,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2894(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,1,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2895(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,1,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2900(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,1,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2901(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,1,4}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove2902(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,1,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2903(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,1,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2904(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,1,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2905(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,1,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2910(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,1,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2911(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,1,4}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove2912(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,1,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2913(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,1,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2914(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,1,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2920(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,2,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2921(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,2,4}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove2922(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,2,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2923(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,2,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2924(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,2,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2925(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,2,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2930(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,2,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2931(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,2,4}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove2932(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,2,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2933(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,2,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2934(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,2,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2935(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,2,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2940(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,2,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2941(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,2,4}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove2942(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,2,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2943(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,2,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2944(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,2,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2945(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,2,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2950(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,2,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2951(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,2,4}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove2952(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,2,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2953(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,2,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2954(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,2,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2955(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,2,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2960(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,2,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2961(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,2,4}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove2962(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,2,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2963(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,2,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2964(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,2,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2965(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,2,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2970(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,2,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2971(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,2,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2972(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,2,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2973(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,2,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2974(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,2,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2980(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,2,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2981(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,2,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2982(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,2,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2983(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,2,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2984(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,2,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove2990(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,2,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove2991(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,2,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove2992(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,2,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove2993(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,2,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove2994(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,2,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove3000(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,2,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove3001(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,2,4}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove3002(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,2,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove3003(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,2,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove3004(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,2,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove3005(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,2,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove3010(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,2,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove3011(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,2,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove3012(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,2,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove3013(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,2,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove3014(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,2,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove3020(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,2,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove3021(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,2,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove3022(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,2,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove3023(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,2,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove3024(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,2,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove3030(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,2,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove3031(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,2,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove3032(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,2,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove3033(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,2,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove3034(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,2,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove3040(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,2,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove3041(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,2,4}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove3042(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,2,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove3043(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,2,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove3044(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,2,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove3045(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,2,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove3050(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,2,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove3051(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,2,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove3052(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,2,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove3053(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,2,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove3054(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,2,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove3060(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,2,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove3061(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,2,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove3062(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,2,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove3063(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,2,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove3064(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,2,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove3070(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,2,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove3071(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,2,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove3072(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,2,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove3073(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,2,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove3074(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,2,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove3080(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,3,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove3081(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,3,4}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove3082(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,3,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove3083(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,3,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove3084(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,3,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove3085(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,3,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove3090(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,3,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove3091(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,3,4}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove3092(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,3,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove3093(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,3,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove3094(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,3,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove3095(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,3,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove3100(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,3,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove3101(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,3,4}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove3102(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,3,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove3103(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,3,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove3104(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,3,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove3105(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,3,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove3110(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,3,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove3111(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,3,4}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove3112(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,3,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove3113(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,3,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove3114(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,3,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove3115(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,3,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove3120(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,3,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove3121(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,3,4}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove3122(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,3,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove3123(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,3,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove3124(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,3,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove3125(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,3,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove3130(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,3,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove3131(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,3,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove3132(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,3,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove3133(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,3,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove3134(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,3,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove3140(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,3,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove3141(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,3,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove3142(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,3,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove3143(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,3,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove3144(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,3,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove3150(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,3,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove3151(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,3,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove3152(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,3,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove3153(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,3,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove3154(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,3,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove3160(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,3,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove3161(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,3,4}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove3162(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,3,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove3163(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,3,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove3164(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,3,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove3165(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,3,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove3170(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,3,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove3171(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,3,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove3172(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,3,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove3173(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,3,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove3174(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,3,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove3180(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,3,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove3181(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,3,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove3182(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,3,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove3183(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,3,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove3190(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,3,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove3191(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,3,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove3192(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,3,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove3193(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,3,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove3200(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,3,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove3201(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,3,4}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove3202(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,3,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove3203(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,3,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove3204(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,3,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove3205(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,3,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove3210(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,3,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove3211(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,3,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove3212(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,3,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove3213(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,3,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove3214(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,3,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove3220(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,3,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove3221(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,3,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove3222(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,3,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove3223(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,3,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove3230(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,3,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove3231(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,3,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove3232(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,3,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove3233(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,3,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove3240(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,4,4}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove3241(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,4,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove3242(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,4,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove3243(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,4,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove3244(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,1,4,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove3250(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,4,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove3251(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,4,4}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove3252(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,4,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove3253(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,4,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove3254(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,4,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove3255(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,1,4,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove3260(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,4,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove3261(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,4,4}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove3262(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,4,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove3263(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,4,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove3264(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,4,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove3265(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,1,4,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove3270(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,4,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove3271(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,4,4}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove3272(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,4,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove3273(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,4,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove3274(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,1,4,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove3280(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,4,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove3281(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,4,4}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove3282(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,4,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove3283(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,4,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove3284(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,4,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove3285(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,2,4,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove3290(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,4,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove3291(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,4,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove3292(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,4,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove3293(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,4,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove3294(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,2,4,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove3300(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,4,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove3301(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,4,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove3302(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,4,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove3303(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,4,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove3304(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,2,4,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove3310(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,4,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove3311(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,4,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove3312(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,4,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove3313(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,4,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove3314(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,2,4,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove3320(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,4,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove3321(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,4,4}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove3322(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,4,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove3323(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,4,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove3324(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,4,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove3325(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,3,4,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove3330(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,4,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove3331(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,4,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove3332(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,4,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove3333(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,4,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove3334(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,3,4,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove3340(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,4,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove3341(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,4,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove3342(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,4,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove3343(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,3,4,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove3350(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,4,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove3351(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,4,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove3352(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,4,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove3353(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,3,4,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove3360(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,4,4}) {
		    map.put(i);
		  }
		  map.remove(1);
		}

		public void testRemove3361(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,4,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove3362(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,4,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove3363(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,4,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove3364(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{1,4,4,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove3370(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,4,4}) {
		    map.put(i);
		  }
		  map.remove(2);
		}

		public void testRemove3371(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,4,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove3372(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,4,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove3373(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,4,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove3374(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{2,4,4,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove3380(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,4,4}) {
		    map.put(i);
		  }
		  map.remove(3);
		}

		public void testRemove3381(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,4,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove3382(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,4,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove3383(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{3,4,4,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}

		public void testRemove3390(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,4,4}) {
		    map.put(i);
		  }
		  map.remove(4);
		}

		public void testRemove3391(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,4,4}) {
		    map.put(i);
		  }
		  map.remove(-10000);
		}

		public void testRemove3392(){
		  TreeMap map=new TreeMap();
		  for (  int i : new int[]{4,4,4,4}) {
		    map.put(i);
		  }
		  map.remove(5);
		}


	
	//
//	public void testExhRemove0() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove1() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove2() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove3() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove4() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove5() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove6() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove7() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove8() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove9() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove10() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove11() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove12() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove13() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove14() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove15() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove16() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove17() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove18() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove19() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove20() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 1, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove21() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 1, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove22() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 1, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove23() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 1, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove24() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 2, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove25() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 2, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove26() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 2, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove27() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 2, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove28() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 3, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove29() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 3, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove30() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 3, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove31() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 3, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove32() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 4, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove33() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 4, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove34() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 4, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove35() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 4, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove36() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 1, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove37() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 1, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove38() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 1, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove39() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 1, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove40() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 2, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove41() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 2, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove42() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 2, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove43() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 2, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove44() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 3, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove45() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 3, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove46() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 3, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove47() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 3, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove48() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 4, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove49() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 4, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove50() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 4, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove51() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 4, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove52() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 1, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove53() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 1, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove54() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 1, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove55() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 1, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove56() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 2, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove57() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 2, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove58() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 2, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove59() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 2, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove60() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 3, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove61() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 3, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove62() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 3, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove63() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 3, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove64() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 4, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove65() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 4, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove66() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 4, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove67() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 4, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove68() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 1, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove69() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 1, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove70() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 1, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove71() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 1, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove72() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 2, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove73() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 2, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove74() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 2, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove75() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 2, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove76() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 3, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove77() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 3, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove78() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 3, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove79() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 3, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove80() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 4, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove81() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 4, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove82() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 4, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove83() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 4, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove84() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 1, 1, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove85() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 1, 1, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove86() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 1, 1, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove87() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 1, 1, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove88() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 2, 1, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove89() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 2, 1, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove90() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 2, 1, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove91() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 2, 1, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove92() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 3, 1, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove93() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 3, 1, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove94() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 3, 1, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove95() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 3, 1, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove96() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 4, 1, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove97() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 4, 1, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove98() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 4, 1, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove99() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 4, 1, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove100() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 1, 2, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove101() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 1, 2, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove102() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 1, 2, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove103() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 1, 2, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove104() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 2, 2, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove105() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 2, 2, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove106() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 2, 2, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove107() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 2, 2, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove108() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 3, 2, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove109() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 3, 2, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove110() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 3, 2, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove111() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 3, 2, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove112() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 4, 2, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove113() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 4, 2, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove114() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 4, 2, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove115() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 4, 2, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove116() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 1, 3, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove117() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 1, 3, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove118() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 1, 3, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove119() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 1, 3, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove120() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 2, 3, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove121() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 2, 3, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove122() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 2, 3, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove123() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 2, 3, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove124() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 3, 3, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove125() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 3, 3, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove126() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 3, 3, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove127() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 3, 3, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove128() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 4, 3, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove129() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 4, 3, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove130() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 4, 3, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove131() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 4, 3, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove132() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 1, 4, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove133() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 1, 4, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove134() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 1, 4, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove135() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 1, 4, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove136() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 2, 4, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove137() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 2, 4, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove138() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 2, 4, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove139() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 2, 4, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove140() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 3, 4, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove141() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 3, 4, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove142() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 3, 4, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove143() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 3, 4, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove144() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 4, 4, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove145() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 4, 4, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove146() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 4, 4, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove147() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 4, 4, 1 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove148() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 1, 1, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove149() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 1, 1, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove150() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 1, 1, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove151() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 1, 1, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove152() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 2, 1, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove153() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 2, 1, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove154() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 2, 1, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove155() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 2, 1, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove156() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 3, 1, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove157() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 3, 1, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove158() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 3, 1, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove159() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 3, 1, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove160() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 4, 1, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove161() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 4, 1, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove162() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 4, 1, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove163() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 4, 1, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove164() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 1, 2, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove165() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 1, 2, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove166() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 1, 2, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove167() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 1, 2, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove168() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 2, 2, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove169() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 2, 2, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove170() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 2, 2, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove171() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 2, 2, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove172() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 3, 2, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove173() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 3, 2, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove174() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 3, 2, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove175() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 3, 2, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove176() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 4, 2, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove177() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 4, 2, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove178() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 4, 2, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove179() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 4, 2, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove180() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 1, 3, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove181() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 1, 3, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove182() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 1, 3, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove183() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 1, 3, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove184() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 2, 3, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove185() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 2, 3, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove186() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 2, 3, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove187() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 2, 3, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove188() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 3, 3, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove189() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 3, 3, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove190() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 3, 3, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove191() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 3, 3, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove192() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 4, 3, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove193() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 4, 3, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove194() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 4, 3, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove195() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 4, 3, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove196() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 1, 4, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove197() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 1, 4, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove198() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 1, 4, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove199() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 1, 4, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove200() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 2, 4, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove201() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 2, 4, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove202() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 2, 4, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove203() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 2, 4, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove204() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 3, 4, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove205() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 3, 4, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove206() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 3, 4, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove207() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 3, 4, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove208() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 4, 4, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove209() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 4, 4, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove210() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 4, 4, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove211() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 4, 4, 2 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove212() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 1, 1, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove213() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 1, 1, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove214() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 1, 1, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove215() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 1, 1, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove216() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 2, 1, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove217() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 2, 1, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove218() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 2, 1, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove219() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 2, 1, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove220() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 3, 1, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove221() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 3, 1, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove222() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 3, 1, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove223() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 3, 1, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove224() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 4, 1, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove225() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 4, 1, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove226() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 4, 1, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove227() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 4, 1, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove228() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 1, 2, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove229() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 1, 2, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove230() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 1, 2, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove231() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 1, 2, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove232() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 2, 2, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove233() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 2, 2, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove234() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 2, 2, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove235() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 2, 2, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove236() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 3, 2, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove237() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 3, 2, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove238() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 3, 2, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove239() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 3, 2, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove240() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 4, 2, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove241() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 4, 2, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove242() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 4, 2, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove243() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 4, 2, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove244() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 1, 3, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove245() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 1, 3, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove246() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 1, 3, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove247() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 1, 3, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove248() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 2, 3, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove249() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 2, 3, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove250() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 2, 3, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove251() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 2, 3, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove252() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 3, 3, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove253() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 3, 3, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove254() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 3, 3, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove255() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 3, 3, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove256() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 4, 3, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove257() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 4, 3, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove258() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 4, 3, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove259() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 4, 3, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove260() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 1, 4, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove261() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 1, 4, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove262() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 1, 4, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove263() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 1, 4, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove264() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 2, 4, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove265() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 2, 4, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove266() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 2, 4, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove267() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 2, 4, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove268() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 3, 4, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove269() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 3, 4, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove270() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 3, 4, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove271() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 3, 4, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove272() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 4, 4, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove273() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 4, 4, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove274() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 4, 4, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove275() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 4, 4, 3 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove276() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 1, 1, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove277() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 1, 1, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove278() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 1, 1, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove279() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 1, 1, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove280() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 2, 1, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove281() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 2, 1, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove282() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 2, 1, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove283() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 2, 1, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove284() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 3, 1, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove285() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 3, 1, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove286() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 3, 1, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove287() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 3, 1, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove288() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 4, 1, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove289() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 4, 1, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove290() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 4, 1, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove291() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 4, 1, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove292() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 1, 2, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove293() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 1, 2, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove294() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 1, 2, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove295() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 1, 2, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove296() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 2, 2, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove297() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 2, 2, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove298() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 2, 2, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove299() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 2, 2, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove300() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 3, 2, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove301() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 3, 2, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove302() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 3, 2, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove303() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 3, 2, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove304() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 4, 2, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove305() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 4, 2, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove306() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 4, 2, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove307() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 4, 2, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove308() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 1, 3, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove309() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 1, 3, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove310() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 1, 3, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove311() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 1, 3, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove312() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 2, 3, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove313() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 2, 3, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove314() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 2, 3, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove315() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 2, 3, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove316() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 3, 3, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove317() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 3, 3, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove318() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 3, 3, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove319() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 3, 3, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove320() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 4, 3, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove321() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 4, 3, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove322() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 4, 3, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove323() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 4, 3, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove324() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 1, 4, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove325() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 1, 4, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove326() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 1, 4, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove327() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 1, 4, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove328() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 2, 4, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove329() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 2, 4, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove330() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 2, 4, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove331() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 2, 4, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove332() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 3, 4, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove333() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 3, 4, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove334() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 3, 4, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove335() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 3, 4, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove336() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 1, 4, 4, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove337() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 2, 4, 4, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove338() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 3, 4, 4, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}
//
//	public void testExhRemove339() {
//		TreeMap map = new TreeMap();
//		for (int i : new int[] { 4, 4, 4, 4 }) {
//			map.put(i);
//		}
//		map.remove(1);
//		map.remove(-10000);
//		map.remove(2);
//		map.remove(4);
//		map.remove(3);
//	}

	// =

	public void testRemoveMutate111() {
		TreeMap map = new TreeMap();
		map.put(3);
		map.put(1);
		map.put(3);
		map.remove(3);
	}

	public void testRemoveMutate122() {
		TreeMap map = new TreeMap();
		map.put(3);
		map.put(1);
		map.put(3);
		map.remove(0);
	}

	public void testRemoveMutate133() {
		TreeMap map = new TreeMap();
		map.put(3);
		map.put(1);
		map.put(3);
		map.remove(-10000);
	}

	public void testRemoveMutate134() {
		TreeMap map = new TreeMap();
		map.put(3);
		map.put(1);
		map.put(3);
		map.remove(2);
	}

	public void testRemoveMutate135() {
		TreeMap map = new TreeMap();
		map.put(3);
		map.put(1);
		map.put(3);
		map.remove(4);
	}

	public void testRemoveMutate136() {
		TreeMap map = new TreeMap();
		map.put(3);
		map.put(1);
		map.put(3);
		map.remove(1);
	}

	public void testRemoveMutate11() {
		TreeMap map = new TreeMap();
		map.put(3);
		map.put(3);
		map.put(3);
		map.remove(3);
	}

	public void testRemoveMutate12() {
		TreeMap map = new TreeMap();
		map.put(3);
		map.put(3);
		map.put(3);
		map.remove(0);
	}

	public void testRemoveMutate13() {
		TreeMap map = new TreeMap();
		map.put(1);
		map.put(3);
		map.put(2);
		map.remove(-10000);
	}

	public void testRemoveMutate2() {
		TreeMap map = new TreeMap();
		map.put(1);
		map.put(3);
		map.put(2);
		map.remove(3);
	}

	public void testRemoveMutate3() {
		TreeMap map = new TreeMap();
		map.put(1);
		map.put(3);
		map.put(2);
		map.remove(2);
	}

	public void testRemoveMutate4() {
		TreeMap map = new TreeMap();
		map.put(1);
		map.put(3);
		map.put(2);
		map.remove(1);
	}

	public void testRemoveMutate5() {
		TreeMap map = new TreeMap();
		map.put(1);
		map.put(3);
		map.put(2);
		map.remove(-10000);
	}

	// TreeMap map = new TreeMap();
	// map.putOne(5);
	// map.putOne(4);
	// map.putOne(3);
	// map.putOne(2);
	// map.putOne(1);
	// map.remove(0);

	// very useful!!!
	public void testRemoveOutOfOrder() {
		TreeMap map = new TreeMap();
		map.put(5);
		map.put(4);
		map.put(3);
		map.put(2);
		map.put(1);
		map.remove(4);
	}

	public void testRemoveOutOfOrder1() {
		TreeMap map = new TreeMap();
		map.put(5);
		map.put(4);
		map.put(3);
		map.put(2);
		map.put(1);
		map.remove(2);
	}

	public void testRemoveOutOfOrder2() {
		TreeMap map = new TreeMap();
		map.put(5);
		map.put(4);
		map.put(3);
		map.put(2);
		map.put(1);
		map.remove(1);
	}

	public void testRemoveOutOfOrder3() {
		TreeMap map = new TreeMap();
		map.put(5);
		map.put(4);
		map.put(3);
		map.put(2);
		map.put(1);
		map.remove(3);
	}

	public void testRemoveOutOfOrder4() {
		TreeMap map = new TreeMap();
		map.put(5);
		map.put(4);
		map.put(3);
		map.put(2);
		map.put(1);
		map.remove(5);
	}

	public void testRemoveOutOfOrder5() {
		TreeMap map = new TreeMap();
		map.put(5);
		map.put(4);
		map.put(3);
		map.put(2);
		map.put(1);
		map.remove(6);
	}

	public void testRemoveOutOfOrder6() {
		TreeMap map = new TreeMap();
		map.put(5);
		map.put(4);
		map.put(3);
		map.put(2);
		map.put(1);
		map.remove(-10000);
	}

	public void testEmptyMap() {
		TreeMap map = new TreeMap();
		map.remove(0);
		map.print();
		map.toString();
		map.size();
	}

	// TreeMap map = new TreeMap();
	// map.putOne(0);
	// map.putOne(1);
	// map.putOne(2);
	// map.putOne(3);
	// map.putOne(4);
	// map.remove(0);
	public void testTreeMapRemove1() {
		TreeMap map = new TreeMap();
		map.put(1);
		map.put(2);
		map.put(3);
		map.put(4);
		map.remove(0);
	}

	public void testTreeMapRemove2() {
		TreeMap map = new TreeMap();
		map.put(1);
		map.put(2);
		map.put(3);
		map.put(4);
		map.remove(-10000);
	}

	public void testTreeMapRemove3() {
		TreeMap map = new TreeMap();
		map.put(1);
		map.put(2);
		map.put(3);
		map.put(4);
		map.remove(3);
	}

	public void testTreeMapRemove4() {
		TreeMap map = new TreeMap();
		map.put(1);
		map.put(2);
		map.put(3);
		map.put(4);
		map.remove(2);
	}

	public void testTreeMapRemove5() {
		TreeMap map = new TreeMap();
		map.put(1);
		map.put(2);
		map.put(3);
		map.put(4);
		map.remove(4);
	}

	public void testTreeMapRemove6() {
		TreeMap map = new TreeMap();
		map.put(1);
		map.put(2);
		map.put(3);
		map.put(4);
		map.remove(5);
	}

	// #From this sketch we generate
	// public void testTreeMap() {
	// TreeMap map = new TreeMap();
	// map.put(1);
	// map.put(3);
	// map.put(2);
	// map.put(4);
	// map.remove(Values.symbolicInt());
	// Observer.observerExpr(map.size());
	// map.print();
	// }

	public void testRemove1() {
		TreeMap map = new TreeMap();
		map.put(1);
		map.put(3);
		map.put(2);
		map.put(4);
		map.remove(1);
		assert map.size() == 3;
		map.print();
	}

	public void testRemove2() {
		TreeMap map = new TreeMap();
		map.put(1);
		map.put(3);
		map.put(2);
		map.put(4);
		map.remove(-10000);
		assert map.size() == 4;
		map.print();
	}

	public void testRemove3() {
		TreeMap map = new TreeMap();
		map.put(1);
		map.put(3);
		map.put(2);
		map.put(4);
		map.remove(3);
		assert map.size() == 3;
		map.print();
	}

	public void testRemove4() {
		TreeMap map = new TreeMap();
		map.put(1);
		map.put(3);
		map.put(2);
		map.put(4);
		map.remove(1);
		assert map.size() == 3;
		map.print();
	}

	public void testRemove5() {
		TreeMap map = new TreeMap();
		map.put(1);
		map.put(3);
		map.put(2);
		map.put(4);
		map.remove(1);
		assert map.size() == 3;
		map.print();
	}

	// TreeMap map = new TreeMap();
	// map.putOne(1);
	// map.putOne(3);
	// map.putOne(2);
	// map.putOne(4);
	// map.putOne(5);

	public void testPut0() {
		TreeMap map = new TreeMap();
		map.put(-10000);
		map.put(-10000);
		map.put(-10000);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut1() {
		TreeMap map = new TreeMap();
		map.put(-10000);
		map.put(-10000);
		map.put(-10000);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut2() {
		TreeMap map = new TreeMap();
		map.put(-9999);
		map.put(-9999);
		map.put(-10000);
		map.put(-9999);
		map.size();
		map.print();
	}

	public void testPut3() {
		TreeMap map = new TreeMap();
		map.put(-9999);
		map.put(-9999);
		map.put(-10000);
		map.put(-9999);
		map.size();
		map.print();
	}

	public void testPut4() {
		TreeMap map = new TreeMap();
		map.put(-10000);
		map.put(-10000);
		map.put(-9999);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut5() {
		TreeMap map = new TreeMap();
		map.put(-10000);
		map.put(-10000);
		map.put(-9999);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut6() {
		TreeMap map = new TreeMap();
		map.put(-10000);
		map.put(-9999);
		map.put(-9999);
		map.put(-9999);
		map.size();
		map.print();
	}

	public void testPut7() {
		TreeMap map = new TreeMap();
		map.put(-10000);
		map.put(-9999);
		map.put(-9999);
		map.put(-9999);
		map.size();
		map.print();
	}

	public void testPut8() {
		TreeMap map = new TreeMap();
		map.put(-10000);
		map.put(-9999);
		map.put(-9999);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut9() {
		TreeMap map = new TreeMap();
		map.put(-10000);
		map.put(-9999);
		map.put(-9999);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut10() {
		TreeMap map = new TreeMap();
		map.put(-9999);
		map.put(-9998);
		map.put(-9998);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut11() {
		TreeMap map = new TreeMap();
		map.put(-9999);
		map.put(-9998);
		map.put(-9998);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut12() {
		TreeMap map = new TreeMap();
		map.put(-10000);
		map.put(-9998);
		map.put(-9998);
		map.put(-9999);
		map.size();
		map.print();
	}

	public void testPut13() {
		TreeMap map = new TreeMap();
		map.put(-10000);
		map.put(-9998);
		map.put(-9998);
		map.put(-9999);
		map.size();
		map.print();
	}

	public void testPut14() {
		TreeMap map = new TreeMap();
		map.put(-10000);
		map.put(-9999);
		map.put(-9999);
		map.put(-9998);
		map.size();
		map.print();
	}

	public void testPut15() {
		TreeMap map = new TreeMap();
		map.put(-10000);
		map.put(-9999);
		map.put(-9999);
		map.put(-9998);
		map.size();
		map.print();
	}

	public void testPut16() {
		TreeMap map = new TreeMap();
		map.put(-9999);
		map.put(-10000);
		map.put(-10000);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut17() {
		TreeMap map = new TreeMap();
		map.put(-9999);
		map.put(-10000);
		map.put(-10000);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut18() {
		TreeMap map = new TreeMap();
		map.put(-9998);
		map.put(-10000);
		map.put(-9999);
		map.put(-9999);
		map.size();
		map.print();
	}

	public void testPut19() {
		TreeMap map = new TreeMap();
		map.put(-9998);
		map.put(-10000);
		map.put(-9999);
		map.put(-9999);
		map.size();
		map.print();
	}

	public void testPut20() {
		TreeMap map = new TreeMap();
		map.put(-9999);
		map.put(-9999);
		map.put(-10000);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut21() {
		TreeMap map = new TreeMap();
		map.put(-9999);
		map.put(-9999);
		map.put(-10000);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut22() {
		TreeMap map = new TreeMap();
		map.put(-9998);
		map.put(-9999);
		map.put(-10000);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut23() {
		TreeMap map = new TreeMap();
		map.put(-9998);
		map.put(-9999);
		map.put(-10000);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut24() {
		TreeMap map = new TreeMap();
		map.put(-9999);
		map.put(-9998);
		map.put(-10000);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut25() {
		TreeMap map = new TreeMap();
		map.put(-9999);
		map.put(-9998);
		map.put(-10000);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut26() {
		TreeMap map = new TreeMap();
		map.put(-9999);
		map.put(-10000);
		map.put(-9999);
		map.put(-9999);
		map.size();
		map.print();
	}

	public void testPut27() {
		TreeMap map = new TreeMap();
		map.put(-9999);
		map.put(-10000);
		map.put(-9999);
		map.put(-9999);
		map.size();
		map.print();
	}

	public void testPut28() {
		TreeMap map = new TreeMap();
		map.put(-9999);
		map.put(-10000);
		map.put(-9999);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut29() {
		TreeMap map = new TreeMap();
		map.put(-9999);
		map.put(-10000);
		map.put(-9999);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut30() {
		TreeMap map = new TreeMap();
		map.put(-9998);
		map.put(-9999);
		map.put(-9998);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut31() {
		TreeMap map = new TreeMap();
		map.put(-9998);
		map.put(-9999);
		map.put(-9998);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut32() {
		TreeMap map = new TreeMap();
		map.put(-9998);
		map.put(-10000);
		map.put(-9998);
		map.put(-9999);
		map.size();
		map.print();
	}

	public void testPut33() {
		TreeMap map = new TreeMap();
		map.put(-9998);
		map.put(-10000);
		map.put(-9998);
		map.put(-9999);
		map.size();
		map.print();
	}

	public void testPut34() {
		TreeMap map = new TreeMap();
		map.put(-9999);
		map.put(-10000);
		map.put(-9999);
		map.put(-9998);
		map.size();
		map.print();
	}

	public void testPut35() {
		TreeMap map = new TreeMap();
		map.put(-9999);
		map.put(-10000);
		map.put(-9999);
		map.put(-9998);
		map.size();
		map.print();
	}

	public void testPut36() {
		TreeMap map = new TreeMap();
		map.put(-10000);
		map.put(-9999);
		map.put(-10000);
		map.put(-9999);
		map.size();
		map.print();
	}

	public void testPut37() {
		TreeMap map = new TreeMap();
		map.put(-10000);
		map.put(-9999);
		map.put(-10000);
		map.put(-9999);
		map.size();
		map.print();
	}

	public void testPut38() {
		TreeMap map = new TreeMap();
		map.put(-10000);
		map.put(-10000);
		map.put(-10000);
		map.put(-9999);
		map.size();
		map.print();
	}

	public void testPut39() {
		TreeMap map = new TreeMap();
		map.put(-10000);
		map.put(-10000);
		map.put(-10000);
		map.put(-9999);
		map.size();
		map.print();
	}

	public void testPut40() {
		TreeMap map = new TreeMap();
		map.put(-9999);
		map.put(-10000);
		map.put(-9999);
		map.put(-9998);
		map.size();
		map.print();
	}

	public void testPut41() {
		TreeMap map = new TreeMap();
		map.put(-9999);
		map.put(-10000);
		map.put(-9999);
		map.put(-9998);
		map.size();
		map.print();
	}

	public void testPut42() {
		TreeMap map = new TreeMap();
		map.put(-10000);
		map.put(-9999);
		map.put(-10000);
		map.put(-9998);
		map.size();
		map.print();
	}

	public void testPut43() {
		TreeMap map = new TreeMap();
		map.put(-10000);
		map.put(-9999);
		map.put(-10000);
		map.put(-9998);
		map.size();
		map.print();
	}

	public void testPut44() {
		TreeMap map = new TreeMap();
		map.put(-10000);
		map.put(-9998);
		map.put(-10000);
		map.put(-9999);
		map.size();
		map.print();
	}

	public void testPut45() {
		TreeMap map = new TreeMap();
		map.put(-10000);
		map.put(-9998);
		map.put(-10000);
		map.put(-9999);
		map.size();
		map.print();
	}

	public void testPut46() {
		TreeMap map = new TreeMap();
		map.put(-10000);
		map.put(-9999);
		map.put(-9998);
		map.put(-9999);
		map.size();
		map.print();
	}

	public void testPut47() {
		TreeMap map = new TreeMap();
		map.put(-10000);
		map.put(-9999);
		map.put(-9998);
		map.put(-9999);
		map.size();
		map.print();
	}

	public void testPut48() {
		TreeMap map = new TreeMap();
		map.put(-10000);
		map.put(-9999);
		map.put(-9998);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut49() {
		TreeMap map = new TreeMap();
		map.put(-10000);
		map.put(-9999);
		map.put(-9998);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut50() {
		TreeMap map = new TreeMap();
		map.put(-9999);
		map.put(-9998);
		map.put(-9997);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut51() {
		TreeMap map = new TreeMap();
		map.put(-9999);
		map.put(-9998);
		map.put(-9997);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut52() {
		TreeMap map = new TreeMap();
		map.put(-10000);
		map.put(-9998);
		map.put(-9997);
		map.put(-9999);
		map.size();
		map.print();
	}

	public void testPut53() {
		TreeMap map = new TreeMap();
		map.put(-10000);
		map.put(-9998);
		map.put(-9997);
		map.put(-9999);
		map.size();
		map.print();
	}

	public void testPut54() {
		TreeMap map = new TreeMap();
		map.put(-10000);
		map.put(-9999);
		map.put(-9998);
		map.put(-9998);
		map.size();
		map.print();
	}

	public void testPut55() {
		TreeMap map = new TreeMap();
		map.put(-10000);
		map.put(-9999);
		map.put(-9998);
		map.put(-9998);
		map.size();
		map.print();
	}

	public void testPut56() {
		TreeMap map = new TreeMap();
		map.put(-10000);
		map.put(-9999);
		map.put(-9997);
		map.put(-9998);
		map.size();
		map.print();
	}

	public void testPut57() {
		TreeMap map = new TreeMap();
		map.put(-10000);
		map.put(-9999);
		map.put(-9997);
		map.put(-9998);
		map.size();
		map.print();
	}

	public void testPut58() {
		TreeMap map = new TreeMap();
		map.put(-10000);
		map.put(-9999);
		map.put(-9998);
		map.put(-9997);
		map.size();
		map.print();
	}

	public void testPut59() {
		TreeMap map = new TreeMap();
		map.put(-10000);
		map.put(-9999);
		map.put(-9998);
		map.put(-9997);
		map.size();
		map.print();
	}

	public void testPut60() {
		TreeMap map = new TreeMap();
		map.put(-9999);
		map.put(-10000);
		map.put(-9998);
		map.put(-9999);
		map.size();
		map.print();
	}

	public void testPut61() {
		TreeMap map = new TreeMap();
		map.put(-9999);
		map.put(-10000);
		map.put(-9998);
		map.put(-9999);
		map.size();
		map.print();
	}

	public void testPut62() {
		TreeMap map = new TreeMap();
		map.put(-9999);
		map.put(-10000);
		map.put(-9998);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut63() {
		TreeMap map = new TreeMap();
		map.put(-9999);
		map.put(-10000);
		map.put(-9998);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut64() {
		TreeMap map = new TreeMap();
		map.put(-9998);
		map.put(-9999);
		map.put(-9997);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut65() {
		TreeMap map = new TreeMap();
		map.put(-9998);
		map.put(-9999);
		map.put(-9997);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut66() {
		TreeMap map = new TreeMap();
		map.put(-9998);
		map.put(-10000);
		map.put(-9997);
		map.put(-9999);
		map.size();
		map.print();
	}

	public void testPut67() {
		TreeMap map = new TreeMap();
		map.put(-9998);
		map.put(-10000);
		map.put(-9997);
		map.put(-9999);
		map.size();
		map.print();
	}

	public void testPut68() {
		TreeMap map = new TreeMap();
		map.put(-9999);
		map.put(-10000);
		map.put(-9998);
		map.put(-9998);
		map.size();
		map.print();
	}

	public void testPut69() {
		TreeMap map = new TreeMap();
		map.put(-9999);
		map.put(-10000);
		map.put(-9998);
		map.put(-9998);
		map.size();
		map.print();
	}

	public void testPut70() {
		TreeMap map = new TreeMap();
		map.put(-9999);
		map.put(-10000);
		map.put(-9997);
		map.put(-9998);
		map.size();
		map.print();
	}

	public void testPut71() {
		TreeMap map = new TreeMap();
		map.put(-9999);
		map.put(-10000);
		map.put(-9997);
		map.put(-9998);
		map.size();
		map.print();
	}

	public void testPut72() {
		TreeMap map = new TreeMap();
		map.put(-9999);
		map.put(-10000);
		map.put(-9998);
		map.put(-9997);
		map.size();
		map.print();
	}

	public void testPut73() {
		TreeMap map = new TreeMap();
		map.put(-9999);
		map.put(-10000);
		map.put(-9998);
		map.put(-9997);
		map.size();
		map.print();
	}

	public void testPut74() {
		TreeMap map = new TreeMap();
		map.put(-9998);
		map.put(-10000);
		map.put(-9999);
		map.put(-9999);
		map.size();
		map.print();
	}

	public void testPut75() {
		TreeMap map = new TreeMap();
		map.put(-9998);
		map.put(-10000);
		map.put(-9999);
		map.put(-9999);
		map.size();
		map.print();
	}

	public void testPut76() {
		TreeMap map = new TreeMap();
		map.put(-9998);
		map.put(-10000);
		map.put(-9999);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut77() {
		TreeMap map = new TreeMap();
		map.put(-9998);
		map.put(-10000);
		map.put(-9999);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut78() {
		TreeMap map = new TreeMap();
		map.put(-9997);
		map.put(-9999);
		map.put(-9998);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut79() {
		TreeMap map = new TreeMap();
		map.put(-9997);
		map.put(-9999);
		map.put(-9998);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut80() {
		TreeMap map = new TreeMap();
		map.put(-9997);
		map.put(-10000);
		map.put(-9998);
		map.put(-9999);
		map.size();
		map.print();
	}

	public void testPut81() {
		TreeMap map = new TreeMap();
		map.put(-9997);
		map.put(-10000);
		map.put(-9998);
		map.put(-9999);
		map.size();
		map.print();
	}

	public void testPut82() {
		TreeMap map = new TreeMap();
		map.put(-9998);
		map.put(-10000);
		map.put(-9999);
		map.put(-9998);
		map.size();
		map.print();
	}

	public void testPut83() {
		TreeMap map = new TreeMap();
		map.put(-9998);
		map.put(-10000);
		map.put(-9999);
		map.put(-9998);
		map.size();
		map.print();
	}

	public void testPut84() {
		TreeMap map = new TreeMap();
		map.put(-9997);
		map.put(-10000);
		map.put(-9999);
		map.put(-9998);
		map.size();
		map.print();
	}

	public void testPut85() {
		TreeMap map = new TreeMap();
		map.put(-9997);
		map.put(-10000);
		map.put(-9999);
		map.put(-9998);
		map.size();
		map.print();
	}

	public void testPut86() {
		TreeMap map = new TreeMap();
		map.put(-9998);
		map.put(-10000);
		map.put(-9999);
		map.put(-9997);
		map.size();
		map.print();
	}

	public void testPut87() {
		TreeMap map = new TreeMap();
		map.put(-9998);
		map.put(-10000);
		map.put(-9999);
		map.put(-9997);
		map.size();
		map.print();
	}

	public void testPut88() {
		TreeMap map = new TreeMap();
		map.put(-9999);
		map.put(-10000);
		map.put(-10000);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut89() {
		TreeMap map = new TreeMap();
		map.put(-9999);
		map.put(-10000);
		map.put(-10000);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut90() {
		TreeMap map = new TreeMap();
		map.put(-9998);
		map.put(-9999);
		map.put(-9999);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut91() {
		TreeMap map = new TreeMap();
		map.put(-9998);
		map.put(-9999);
		map.put(-9999);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut92() {
		TreeMap map = new TreeMap();
		map.put(-9999);
		map.put(-10000);
		map.put(-10000);
		map.put(-9999);
		map.size();
		map.print();
	}

	public void testPut93() {
		TreeMap map = new TreeMap();
		map.put(-9999);
		map.put(-10000);
		map.put(-10000);
		map.put(-9999);
		map.size();
		map.print();
	}

	public void testPut94() {
		TreeMap map = new TreeMap();
		map.put(-9998);
		map.put(-10000);
		map.put(-10000);
		map.put(-9999);
		map.size();
		map.print();
	}

	public void testPut95() {
		TreeMap map = new TreeMap();
		map.put(-9998);
		map.put(-10000);
		map.put(-10000);
		map.put(-9999);
		map.size();
		map.print();
	}

	public void testPut96() {
		TreeMap map = new TreeMap();
		map.put(-9999);
		map.put(-10000);
		map.put(-10000);
		map.put(-9998);
		map.size();
		map.print();
	}

	public void testPut97() {
		TreeMap map = new TreeMap();
		map.put(-9999);
		map.put(-10000);
		map.put(-10000);
		map.put(-9998);
		map.size();
		map.print();
	}

	public void testPut98() {
		TreeMap map = new TreeMap();
		map.put(-9998);
		map.put(-10000);
		map.put(-9999);
		map.put(-9999);
		map.size();
		map.print();
	}

	public void testPut99() {
		TreeMap map = new TreeMap();
		map.put(-9998);
		map.put(-10000);
		map.put(-9999);
		map.put(-9999);
		map.size();
		map.print();
	}

	public void testPut100() {
		TreeMap map = new TreeMap();
		map.put(-9998);
		map.put(-10000);
		map.put(-9999);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut101() {
		TreeMap map = new TreeMap();
		map.put(-9998);
		map.put(-10000);
		map.put(-9999);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut102() {
		TreeMap map = new TreeMap();
		map.put(-9997);
		map.put(-9999);
		map.put(-9998);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut103() {
		TreeMap map = new TreeMap();
		map.put(-9997);
		map.put(-9999);
		map.put(-9998);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut104() {
		TreeMap map = new TreeMap();
		map.put(-9997);
		map.put(-10000);
		map.put(-9998);
		map.put(-9999);
		map.size();
		map.print();
	}

	public void testPut105() {
		TreeMap map = new TreeMap();
		map.put(-9997);
		map.put(-10000);
		map.put(-9998);
		map.put(-9999);
		map.size();
		map.print();
	}

	public void testPut106() {
		TreeMap map = new TreeMap();
		map.put(-9998);
		map.put(-10000);
		map.put(-9999);
		map.put(-9998);
		map.size();
		map.print();
	}

	public void testPut107() {
		TreeMap map = new TreeMap();
		map.put(-9998);
		map.put(-10000);
		map.put(-9999);
		map.put(-9998);
		map.size();
		map.print();
	}

	public void testPut108() {
		TreeMap map = new TreeMap();
		map.put(-9997);
		map.put(-10000);
		map.put(-9999);
		map.put(-9998);
		map.size();
		map.print();
	}

	public void testPut109() {
		TreeMap map = new TreeMap();
		map.put(-9997);
		map.put(-10000);
		map.put(-9999);
		map.put(-9998);
		map.size();
		map.print();
	}

	public void testPut110() {
		TreeMap map = new TreeMap();
		map.put(-9998);
		map.put(-10000);
		map.put(-9999);
		map.put(-9997);
		map.size();
		map.print();
	}

	public void testPut111() {
		TreeMap map = new TreeMap();
		map.put(-9998);
		map.put(-10000);
		map.put(-9999);
		map.put(-9997);
		map.size();
		map.print();
	}

	public void testPut112() {
		TreeMap map = new TreeMap();
		map.put(-10000);
		map.put(-9999);
		map.put(-9999);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut113() {
		TreeMap map = new TreeMap();
		map.put(-10000);
		map.put(-9999);
		map.put(-9999);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut114() {
		TreeMap map = new TreeMap();
		map.put(-10000);
		map.put(-9998);
		map.put(-9998);
		map.put(-9999);
		map.size();
		map.print();
	}

	public void testPut115() {
		TreeMap map = new TreeMap();
		map.put(-10000);
		map.put(-9998);
		map.put(-9998);
		map.put(-9999);
		map.size();
		map.print();
	}

	public void testPut116() {
		TreeMap map = new TreeMap();
		map.put(-9999);
		map.put(-9999);
		map.put(-9999);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut117() {
		TreeMap map = new TreeMap();
		map.put(-9999);
		map.put(-9999);
		map.put(-9999);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut118() {
		TreeMap map = new TreeMap();
		map.put(-9999);
		map.put(-9998);
		map.put(-9998);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut119() {
		TreeMap map = new TreeMap();
		map.put(-9999);
		map.put(-9998);
		map.put(-9998);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut120() {
		TreeMap map = new TreeMap();
		map.put(-9998);
		map.put(-9999);
		map.put(-9999);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut121() {
		TreeMap map = new TreeMap();
		map.put(-9998);
		map.put(-9999);
		map.put(-9999);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut122() {
		TreeMap map = new TreeMap();
		map.put(-9998);
		map.put(-9999);
		map.put(-9999);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut123() {
		TreeMap map = new TreeMap();
		map.put(-9998);
		map.put(-9999);
		map.put(-9999);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut124() {
		TreeMap map = new TreeMap();
		map.put(-9998);
		map.put(-9999);
		map.put(-10000);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut125() {
		TreeMap map = new TreeMap();
		map.put(-9998);
		map.put(-9999);
		map.put(-10000);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut126() {
		TreeMap map = new TreeMap();
		map.put(-9997);
		map.put(-9998);
		map.put(-10000);
		map.put(-9999);
		map.size();
		map.print();
	}

	public void testPut127() {
		TreeMap map = new TreeMap();
		map.put(-9997);
		map.put(-9998);
		map.put(-10000);
		map.put(-9999);
		map.size();
		map.print();
	}

	public void testPut128() {
		TreeMap map = new TreeMap();
		map.put(-9997);
		map.put(-9998);
		map.put(-9999);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut129() {
		TreeMap map = new TreeMap();
		map.put(-9997);
		map.put(-9998);
		map.put(-9999);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut130() {
		TreeMap map = new TreeMap();
		map.put(-9998);
		map.put(-9999);
		map.put(-9998);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut131() {
		TreeMap map = new TreeMap();
		map.put(-9998);
		map.put(-9999);
		map.put(-9998);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut132() {
		TreeMap map = new TreeMap();
		map.put(-9997);
		map.put(-9999);
		map.put(-9998);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut133() {
		TreeMap map = new TreeMap();
		map.put(-9997);
		map.put(-9999);
		map.put(-9998);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut134() {
		TreeMap map = new TreeMap();
		map.put(-9998);
		map.put(-9999);
		map.put(-9997);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut135() {
		TreeMap map = new TreeMap();
		map.put(-9998);
		map.put(-9999);
		map.put(-9997);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut136() {
		TreeMap map = new TreeMap();
		map.put(-9999);
		map.put(-9999);
		map.put(-9998);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut137() {
		TreeMap map = new TreeMap();
		map.put(-9999);
		map.put(-9999);
		map.put(-9998);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut138() {
		TreeMap map = new TreeMap();
		map.put(-10000);
		map.put(-9999);
		map.put(-9998);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut139() {
		TreeMap map = new TreeMap();
		map.put(-10000);
		map.put(-9999);
		map.put(-9998);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut140() {
		TreeMap map = new TreeMap();
		map.put(-10000);
		map.put(-9998);
		map.put(-9997);
		map.put(-9999);
		map.size();
		map.print();
	}

	public void testPut141() {
		TreeMap map = new TreeMap();
		map.put(-10000);
		map.put(-9998);
		map.put(-9997);
		map.put(-9999);
		map.size();
		map.print();
	}

	public void testPut142() {
		TreeMap map = new TreeMap();
		map.put(-9999);
		map.put(-9998);
		map.put(-9997);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut143() {
		TreeMap map = new TreeMap();
		map.put(-9999);
		map.put(-9998);
		map.put(-9997);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut144() {
		TreeMap map = new TreeMap();
		map.put(-9998);
		map.put(-9999);
		map.put(-9998);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut145() {
		TreeMap map = new TreeMap();
		map.put(-9998);
		map.put(-9999);
		map.put(-9998);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut146() {
		TreeMap map = new TreeMap();
		map.put(-9998);
		map.put(-9999);
		map.put(-9997);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut147() {
		TreeMap map = new TreeMap();
		map.put(-9998);
		map.put(-9999);
		map.put(-9997);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut148() {
		TreeMap map = new TreeMap();
		map.put(-9997);
		map.put(-9999);
		map.put(-9998);
		map.put(-10000);
		map.size();
		map.print();
	}

	public void testPut149() {
		TreeMap map = new TreeMap();
		map.put(-9997);
		map.put(-9999);
		map.put(-9998);
		map.put(-10000);
		map.size();
		map.print();
	}

	// TreeMap map = new TreeMap();
	// map.putOne(1);
	// map.putOne(3);
	// map.putOne(2);
	// map.concreteStringOne(0);
	// map.toString();

	public void testConcreteString1() {
		TreeMap map = new TreeMap();
		map.put(1);
		map.put(3);
		map.put(2);
		map.concreteString(0);
		System.out.println(map.toString());
	}

	public void testConcreteString2() {
		TreeMap map = new TreeMap();
		map.put(1);
		map.put(3);
		map.put(2);
		map.concreteString(1);
		System.out.println(map.toString());
	}

	public void testConcreteString() {
		TreeMap map = new TreeMap();
		map.put(1);
		map.put(3);
		map.put(2);
		map.concreteString(-10000);
		System.out.println(map.toString());
	}
}